package com.gome.boot.common.util;

import java.util.Collection;
import java.util.Map;

/**
 * 公共工具类.
 *
 * @author baoxiufeng
 */
public class CommonUtils {

    /**
     * 移除给定字符串左侧给定的字符串.
     *
     * @param str 待移除的字符串
     * @param isLeft 是否移除左侧（true-移除左侧、false-移除右侧）
     * @param css 需要移除的字符
     * @return 移除后的字符串
     */
    public static String trim(String str, boolean isLeft, CharSequence... css) {
        if (isEmpty(css)) {
            return isLeft ? str.replaceAll("^\\s+", "") : str.replaceAll("\\s+$", "");
        }
        StringBuilder regex = new StringBuilder();
        if (isLeft) {
            regex.append("^");
        }
        regex.append("[");
        boolean firstFlag = true;
        for (CharSequence cs : css) {
            if (firstFlag) {
                firstFlag = false;
            } else {
                regex.append("|");
            }
            regex.append(isEmpty(cs) ? "\\s" : cs);
        }
        regex.append("]+");
        if (isLeft == false) {
            regex.append("$");
        }
        return str.replaceAll(regex.toString(), "");
    }

    /**
     * 移除给定字符串左侧给定的字符串.
     *
     * @param str 待移除的字符串
     * @param css 需要移除的字符
     * @return 移除后的字符串
     */
    public static String trimLeft(String str, CharSequence... css) {
        return trim(str, true, css);
    }

    /**
     * 移除给定字符串左侧给定的字符串.
     *
     * @param str 待移除的字符串
     * @param css 需要移除的字符
     * @return 移除后的字符串
     */
    public static String trimRight(String str, CharSequence... css) {
        return trim(str, false, css);
    }

    /**
     * 移除指定字符串的前后空字符.
     * <br/>如果给定字符串为null，则保持不变.
     *
     * @param str 待修饰的字符串
     * @return 修饰后的字符串
     */
    public static String trim(String str) {
        return str == null ? null : str.trim();
    }

    /**
     * 移除指定字符串的前后空字符.
     * <br/>如果给定字符串为null，则转换为空字符串.
     *
     * @param str 待修饰的字符串
     * @return 修饰后的字符串
     */
    public static String trimToEmpty(String str) {
        return str == null ? "" : str.trim();
    }

    /**
     * 移除指定字符串的前后空字符.
     * <br/>如果给定字符串为null，则保持不变.
     *
     * @param str 待修饰的字符串
     * @return 修饰后的字符串
     */
    public static String trimToNull(String str) {
        String s = trim(str);
        return isEmpty(s) ? null : s;
    }

    /**
     * 判断给定字符串数组是否为空或数组各成员是否存在空.
     *
     * @param css 待判定的字符串数组
     * @return 判定结果（true：数组为空或存在数组成员为空、false：数组不为空且数组各成员均不为空）
     */
    public static boolean isAnyBlank(CharSequence... css) {
        if (isEmpty(css)) {
            return true;
        }
        for (CharSequence cs : css) {
            if (isEmpty(cs)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断给定字符串数组各成员是否均不为空.
     *
     * @param css 待判定的字符串数组
     * @return 判定结果（true：数组不为空且数组各成员均不为空、false：数组为空或存在数组成员为空）
     */
    public static boolean isNoneBlank(CharSequence... css) {
        return !isAnyBlank(css);
    }

    /**
     * 判断给定字符串数组各成员是否均为空.
     *
     * @param css 待判定的字符串数组
     * @return 判定结果（true：数组为空或数组各成员均为空、false：数组不为空且存在数组成员不为空）
     */
    public static boolean isAllBlank(CharSequence... css) {
        if (isEmpty(css)) {
            return true;
        }
        for (CharSequence cs : css) {
            if (isNotEmpty(cs)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断给定字符串数组各成员是否存在非空.
     *
     * @param css 待判定的字符串数组
     * @return 判定结果（true：数组不为空且存在数组成员不为空、false：数组为空或数组各成员均为空）
     */
    public static boolean isAnyNotBlank(CharSequence... css) {
        return !isAllBlank(css);
    }

    /**
     * 判断给定对象数组是否为空或数组各成员是否存在空.
     *
     * @param objs 待判定的对象数组
     * @return 判定结果（true：数组为空或存在数组成员为空、false：数组不为空且数组各成员均不为空）
     */
    public static boolean isAnyBlank(Object... objs) {
        if (isEmpty(objs)) {
            return true;
        }
        for (Object obj : objs) {
            if (obj == null) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断给定对象数组各成员是否均不为空.
     *
     * @param objs 待判定的对象数组
     * @return 判定结果（true：数组不为空且数组各成员均不为空、false：数组为空或存在数组成员为空）
     */
    public static boolean isNoneBlank(Object... objs) {
        return !isAnyBlank(objs);
    }

    /**
     * 判断给定对象数组是否为空或数组各成员是否存在空.
     *
     * @param objs 待判定的对象数组
     * @return 判定结果（true：数组为空或数组各成员均为空、false：数组不为空且存在数组成员不为空）
     */
    public static boolean isAllBlank(Object... objs) {
        if (isEmpty(objs)) {
            return true;
        }
        for (Object obj : objs) {
            if (obj != null) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断给定对象数组是否为空或数组各成员是否非空.
     *
     * @param objs 待判定的对象数组
     * @return 判定结果（true：数组不为空且存在数组成员不为空、false：数组为空或数组各成员均为空）
     */
    public static boolean isAnyNotBlank(Object... objs) {
        return !isAllBlank(objs);
    }

    /**
     * 判断给定列表数组是否为空或数组各成员是否存在空.
     *
     * @param colls 待判定的列表数组
     * @return 判定结果（true：数组为空或存在数组成员为空、false：数组不为空且数组各成员均不为空）
     */
    public static boolean isAnyBlank(Collection... colls) {
        if (isEmpty(colls)) {
            return true;
        }
        for (Collection coll : colls) {
            if (isEmpty(coll)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断给定列表数组各成员是否均不为空.
     *
     * @param colls 待判定的列表数组
     * @return 判定结果（true：数组不为空且数组各成员均不为空、false：数组为空或存在数组成员为空）
     */
    public static boolean isNoneBlank(Collection... colls) {
        return !isAnyBlank(colls);
    }

    /**
     * 判断给定列表数组是否为空或数组各成员是否存在空.
     *
     * @param colls 待判定的列表数组
     * @return 判定结果（true：数组为空或数组各成员均为空、false：数组不为空且存在数组成员不为空）
     */
    public static boolean isAllBlank(Collection... colls) {
        if (isEmpty(colls)) {
            return true;
        }
        for (Collection coll : colls) {
            if (isNotEmpty(coll)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断给定列表数组是否为空或数组各成员是否非空.
     *
     * @param colls 待判定的列表数组
     * @return 判定结果（true：数组不为空且存在数组成员不为空、false：数组为空或数组各成员均为空）
     */
    public static boolean isAnyNotBlank(Collection... colls) {
        return !isAllBlank(colls);
    }

    /**
     * 转换指定字符串为整数.
     *
     * @param str 待转换的字符串
     * @return 转换后的整数值
     */
    public static int toInt(String str) {
        return toInt(str, 0);
    }

    /**
     * 转换指定字符串为整数，字符串为空或转换失败时使用默认值.
     *
     * @param str 待转换的字符串
     * @param defaultValue 默认值
     * @return 转换后的整数值
     */
    public static int toInt(String str, int defaultValue) {
        if(str == null) {
            return defaultValue;
        } else {
            try {
                return Integer.parseInt(str);
            } catch (NumberFormatException var3) {
                return defaultValue;
            }
        }
    }

    /**
     * 转换指定字符串为长整数.
     *
     * @param str 待转换的字符串
     * @return 转换后的长整数值
     */
    public static long toLong(String str) {
        return toLong(str, 0L);
    }

    /**
     * 转换指定字符串为长整数，字符串为空或转换失败时使用默认值.
     *
     * @param str 待转换的字符串
     * @param defaultValue 默认值
     * @return 转换后的长整数值
     */
    public static long toLong(String str, long defaultValue) {
        if(str == null) {
            return defaultValue;
        } else {
            try {
                return Long.parseLong(str);
            } catch (NumberFormatException var3) {
                return defaultValue;
            }
        }
    }

    /**
     * 判定指定字符串对象是否为空.
     *
     * @param cs 字符串对象
     * @return 判定结果（true：空，false：非空）
     */
    public static boolean isEmpty(CharSequence cs) {
        return cs == null || cs.toString().trim().length() == 0;
    }

    /**
     * 判定指定字符串对象是否非空.
     *
     * @param cs 字符串对象
     * @return 判定结果（true：非空，false：空）
     */
    public static boolean isNotEmpty(CharSequence cs) {
        return !isEmpty(cs);
    }

    /**
     * 判定指定对象是否为空.
     *
     * @param o 对象
     * @return 判定结果（true：空，false：非空）
     */
    public static boolean isEmpty(Object o) {
        return o == null || o.toString().trim().length() == 0;
    }

    /**
     * 判定指定对象是否非空.
     *
     * @param o 对象
     * @return 判定结果（true：非空，false：空）
     */
    public static boolean isNotEmpty(Object o) {
        return !isEmpty(o);
    }

    /**
     * 判定指定集合是否为空.
     *
     * @param coll 待判定的集合对象
     * @return 判定结果（true：空、false：非空）
     */
    public static boolean isEmpty(Collection coll) {
        return coll == null || coll.isEmpty();
    }

    /**
     * 判定指定集合是否不为空.
     *
     * @param coll 待判定的集合对象
     * @return 判定结果（true：非空、false：空）
     */
    public static boolean isNotEmpty(Collection coll) {
        return !isEmpty(coll);
    }

    /**
     * 判定指定集合是否为空.
     *
     * @param m 待判定的集合对象
     * @return 判定结果（true：空、false：非空）
     */
    public static boolean isEmpty(Map m) {
        return m == null || m.isEmpty();
    }

    /**
     * 判定指定集合是否非空.
     *
     * @param m 待判定的集合对象
     * @return 判定结果（true：非空、false：空）
     */
    public static boolean isNotEmpty(Map m) {
        return !isEmpty(m);
    }

    /**
     * 判定指定数组是否为空.
     *
     * @param array 待判定的数据对象
     * @return 判定结果（true：空、false：非空）
     */
    public static boolean isEmpty(Object[] array) {
        return array == null || array.length == 0;
    }

    /**
     * 判定指定数组是否非空.
     *
     * @param array 待判定的数据对象
     * @return 判定结果（true：非空、false：空）
     */
    public static boolean isNotEmpty(Object[] array) {
        return !isEmpty(array);
    }

    /**
     * 判定指定的两个整数是否相等.
     *
     * @param i1 整数1
     * @param i2 整数2
     * @return 判定结果（true：相等、false：不相等）
     */
    public static boolean isEquals(Integer i1, Integer i2) {
        return i1 == null && i2 == null ? true : (i1 != null && i2 != null ? i1.equals(i2) : false);
    }

    /**
     * 判定指定的两个整数是否相等.
     *
     * @param i1 整数1
     * @param i2 整数2
     * @return 判定结果（true：相等、false：不相等）
     */
    public static boolean isNotEquals(Integer i1, Integer i2) {
        return !isEquals(i1, i2);
    }

    /**
     * 判定指定的两个字符串是否相等.
     *
     * @param s1 字符串1
     * @param s2 字符串2
     * @return 判定结果（true：相等、false：不相等）
     */
    public static boolean isEquals(String s1, String s2) {
        return s1 == null && s2 == null ? true : (s1 != null && s2 != null ? s1.equals(s2) : false);
    }

    /**
     * 判定指定的两个字符串是否不相等.
     *
     * @param s1 字符串1
     * @param s2 字符串2
     * @return 判定结果（true：不相等、false：相等）
     */
    public static boolean isNotEquals(String s1, String s2) {
        return !isEquals(s1, s2);
    }

    /**
     * 判断指定集合中是否包含给定对象.
     *
     * @param coll 待判断的集合对象
     * @param value 待判断是否包含的给定对象
     * @return 判断结果（true：包含、false：不包含）
     */
    public static boolean isContains(Collection coll, Object value) {
        if (isNotEmpty(coll) && isNotEmpty(value)) {
            return coll.contains(value);
        }
        return false;
    }

    /**
     * 判断指定集合中是否包含给定对象.
     *
     * @param coll 待判断的集合对象
     * @param value 待判断是否包含的给定对象
     * @return 判断结果（true：不包含、false：包含）
     */
    public static boolean isNotContains(Collection coll, Object value) {
        return !isContains(coll, value);
    }

    /**
     * 判断指定集合中是否包含给定对象.
     *
     * @param coll 待判断的集合对象
     * @param value 待判断是否包含的给定对象
     * @param excludeNull 是否排除空（true：排除空，即value为空则算作包含、false：不排除空，即value为空算作不包含）
     * @return 判断结果（true：包含、false：不包含）
     */
    public static boolean isContains(Collection coll, Object value, boolean excludeNull) {
        if (excludeNull && isEmpty(value)) {
            return true;
        }
        if (isNotEmpty(coll) && isNotEmpty(value)) {
            return coll.contains(value);
        }
        return false;
    }

    /**
     * 判断指定集合中是否包含给定对象.
     *
     * @param coll 待判断的集合对象
     * @param value 待判断是否包含的给定对象
     * @param excludeNull 是否排除空（true：排除空，即value为空则算作包含，false：不排除空，即value为空则算作不包含）
     * @return 判断结果（true：不包含、false：包含）
     */
    public static boolean isNotContains(Collection coll, Object value, boolean excludeNull) {
        return !isContains(coll, value, excludeNull);
    }

    /**
     * 从给定对象列表中获取第一个非空的对象.
     *
     * @param values 对象列表
     * @param <T> 对象类型泛型
     * @return 获取到的第一个非空对象
     */
    public static <T> T nvl(T... values) {
        for (T value : values) {
            if (value != null) {
                return value;
            }
        }
        return null;
    }

    /**
     * 从给定字符串列表中获取第一个非空的字符串.
     *
     * @param values 字符串列表
     * @return 获取到的第一个非空字符串
     */
    public static String nvl(String... values) {
        for (String value : values) {
            if (isNotEmpty(value)) {
                return value;
            }
        }
        return null;
    }
}
